#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
rs_afg.py - 任意函数发生器控制模块

该模块实现了对Tektronix AFG31000系列任意函数发生器的控制，包括：
1. 通道1和通道2的宽度控制
2. 通道1和通道2的周期控制
3. 通道1和通道2的延迟控制
4. 通道1和通道2的输出使能控制
5. 同步模式控制

参考文档：
https://www.tek.com/signal-generator/afg31000-function-generator
"""

from epics import PV, caget, caput, cainfo, poll
from . import read_conf
import sys
import time
#import pyvisa

# 默认配置文件路径
CONF_FILE = '../conf/rs_afg.conf'

class rsAfg(object):
    """
    任意函数发生器控制类
    
    该类实现了对Tektronix AFG31000系列任意函数发生器的控制。
    主要功能包括：
    1. 通道参数控制（宽度、周期、延迟、输出使能）
    2. 同步模式控制
    3. 通道间相对延迟控制
    """
    
    # 通道1宽度控制
    @property
    def channel1_width(self):
        """
        获取通道1宽度
        
        返回：
            float: 通道1宽度值
        """
        return self.afg_channel1_width.get()
        
    @channel1_width.setter
    def channel1_width(self, _width):
        """
        设置通道1宽度
        
        参数：
            _width (float): 要设置的宽度值
        """
        self.afg_channel1_width.put(_width)
    
    # 通道1周期控制
    @property
    def channel1_period(self):
        """
        获取通道1周期
        
        返回：
            float: 通道1周期值
        """
        return self.afg_channel1_period.get()
    
    @channel1_period.setter
    def channel1_period(self, _period):
        """
        设置通道1周期
        
        参数：
            _period (float): 要设置的周期值
        """
        self.afg_channel1_period.put(_period)
    
    # 通道1延迟控制（通道2相对于通道1的延迟）
    @property
    def channel1_delay(self):
        """
        获取通道1延迟
        
        返回：
            float: 通道1延迟值
        """
        return self.afg_channel1_delay.get()
    
    @channel1_delay.setter
    def channel1_delay(self, _delay):
        """
        设置通道1延迟
        
        参数：
            _delay (float): 要设置的延迟值
        """
        self.afg_channel1_delay.put(_delay)
    
    # 通道1输出使能控制
    @property
    def channel1_output_enable(self):
        """
        获取通道1输出使能状态
        
        返回：
            int: 通道1输出使能状态（0或1）
        """
        return self.afg_channel1_output_enable.get()
    
    @channel1_output_enable.setter
    def channel1_output_enable(self, _status):
        """
        设置通道1输出使能状态
        
        参数：
            _status (int): 要设置的使能状态（0或1）
        """
        self.afg_channel1_output_enable.put(_status)
        
    # 通道2宽度控制
    @property
    def channel2_width(self):
        """
        获取通道2宽度
        
        返回：
            float: 通道2宽度值
        """
        return self.afg_channel2_width.get()
        
    @channel2_width.setter
    def channel2_width(self, _width):
        """
        设置通道2宽度
        
        参数：
            _width (float): 要设置的宽度值
        """
        self.afg_channel2_width.put(_width)
    
    # 通道2周期控制
    @property
    def channel2_period(self):
        """
        获取通道2周期
        
        返回：
            float: 通道2周期值
        """
        return self.afg_channel2_period.get()
    
    @channel2_period.setter
    def channel2_period(self, _period):
        """
        设置通道2周期
        
        参数：
            _period (float): 要设置的周期值
        """
        self.afg_channel2_period.put(_period)
    
    # 通道2延迟控制
    @property
    def channel2_delay(self):
        """
        获取通道2延迟
        
        返回：
            float: 通道2延迟值
        """
        return self.afg_channel2_delay.get()
    
    @channel2_delay.setter
    def channel2_delay(self, _delay):
        """
        设置通道2延迟
        
        参数：
            _delay (float): 要设置的延迟值
        """
        self.afg_channel2_delay.put(_delay)
    
    # 通道2输出使能控制
    @property
    def channel2_output_enable(self):
        """
        获取通道2输出使能状态
        
        返回：
            int: 通道2输出使能状态（0或1）
        """
        return self.afg_channel2_output_enable.get()
    
    @channel2_output_enable.setter
    def channel2_output_enable(self, _status):
        """
        设置通道2输出使能状态
        
        参数：
            _status (int): 要设置的使能状态（0或1）
        """
        self.afg_channel2_output_enable.put(_status)

    # 通道宽度控制（同步模式）
    @property
    def channel_width(self):
        """
        获取通道宽度
        
        返回：
            float 或 tuple: 同步模式下返回单个值，非同步模式下返回(通道1宽度, 通道2宽度)
        """
        if self.sync == 1:
            return self.channel1_width
        else:
            return (self.channel1_width, self.channel2_width)
    
    @channel_width.setter
    def channel_width(self, _width):
        """
        设置通道宽度
        
        参数：
            _width (float 或 tuple): 同步模式下为单个值，非同步模式下为(通道1宽度, 通道2宽度)
        """
        if self.sync == 1:
            self.channel1_width = _width
            self.channel2_width = _width
        else:
            self.channel1_width = _width[0]
            self.channel2_width = _width[1]
        
    # 通道周期控制（同步模式）
    @property
    def channel_period(self):
        """
        获取通道周期
        
        返回：
            float 或 tuple: 同步模式下返回单个值，非同步模式下返回(通道1周期, 通道2周期)
        """
        if self.sync == 1:
            return self.channel1_period
        else:
            return (self.channel1_period, self.channel2_period)
    
    @channel_period.setter
    def channel_period(self, _period):
        """
        设置通道周期
        
        参数：
            _period (float 或 tuple): 同步模式下为单个值，非同步模式下为(通道1周期, 通道2周期)
        """
        if self.sync == 1:
            self.channel1_period = _period
            self.channel2_period = _period
        else:
            self.channel1_period = _period[0]
            self.channel2_period = _period[1]
        
    # 通道延迟控制（同步模式）
    @property
    def channel_delay(self):
        """
        获取通道延迟
        
        返回：
            float 或 tuple: 通道延迟相同时返回单个值，否则返回(通道1延迟, 通道2延迟)
        """
        if self.channel1_delay == self.channel2_delay:
            return self.channel1_delay
        else:
            return (self.channel1_delay, self.channel2_delay)
    
    @channel_delay.setter
    def channel_delay(self, _delay = (0.,)):
        """
        设置通道延迟
        
        参数：
            _delay (float 或 tuple): 同步模式下为单个值，非同步模式下为(通道1延迟, 通道2延迟)
        """
        if self.sync == 1:
            self.channel1_delay = self.offset
            self.channel2_delay = _delay + self.offset
        else:
            self.channel1_delay = _delay[0]
            self.channel2_delay = _delay[1]
        
    # 通道输出使能控制（同步模式）
    @property
    def channel_output_enable(self):
        """
        获取通道输出使能状态
        
        返回：
            int 或 tuple: 通道使能状态相同时返回单个值，否则返回(通道1使能状态, 通道2使能状态)
        """
        if self.channel1_output_enable == self.channel2_output_enable:
            return self.channel1_output_enable
        else:
            return (self.channel1_output_enable, self.channel2_output_enable)
    
    @channel_width.setter
    def channel_output_enable(self, _status = (0.,)):
        """
        设置通道输出使能状态
        
        参数：
            _status (int 或 tuple): 同步模式下为单个值，非同步模式下为(通道1使能状态, 通道2使能状态)
        """
        if self.sync == 1:
            self.channel1_output_enable = _status
            self.channel2_output_enable = _status
        else:
            self.channel1_output_enable = _status[0]
            self.channel2_output_enable = _status[1]

    def __init__(self, pv_dict, *args, **kwargs):
        """
        初始化任意函数发生器控制对象
        
        参数：
            pv_dict (dict): PV配置字典，包含：
                - sync: 同步模式标志
                - afg_channel1_width: 通道1宽度PV
                - afg_channel1_period: 通道1周期PV
                - afg_channel1_delay: 通道1延迟PV
                - afg_channel1_output_enable: 通道1输出使能PV
                - afg_channel2_width: 通道2宽度PV
                - afg_channel2_period: 通道2周期PV
                - afg_channel2_delay: 通道2延迟PV
                - afg_channel2_output_enable: 通道2输出使能PV
        """
        self.afg_name = 'Abitrary Function generator'
        self.pv_dict = pv_dict
        self.offset = 0
        self.sync = int(self.pv_dict['sync'])
        self.afg_channel1_width = PV(self.pv_dict['afg_channel1_width'][1])    # 宽度，单位：？
        self.afg_channel1_period = PV(self.pv_dict['afg_channel1_period'][1])    # 周期
        self.afg_channel1_delay = PV(self.pv_dict['afg_channel1_delay'][1])    # 延迟
        self.afg_channel1_output_enable = PV(self.pv_dict['afg_channel1_output_enable'][1])    # 输出使能
        self.afg_channel2_width = PV(self.pv_dict['afg_channel2_width'][1])    # 宽度，单位：？
        self.afg_channel2_period = PV(self.pv_dict['afg_channel2_period'][1])    # 周期
        self.afg_channel2_delay = PV(self.pv_dict['afg_channel2_delay'][1])    # 延迟
        self.afg_channel2_output_enable = PV(self.pv_dict['afg_channel2_output_enable'][1])    # 输出使能

    def __del__(self):
        """
        析构函数，打印删除实例信息
        """
        print('Delete rs_afg.rsAfg instance -> '+self.afg_name)

def main():
    """
    主函数
    
    功能：
    1. 处理命令行参数
    2. 加载配置文件
    3. 创建并返回AFG控制对象
    """
    global CONF_FILE
    cmd_argv = str(sys.argv)
    if (len(sys.argv) != 2):
        print('Loading default configure file ', CONF_FILE)
    else:
        CONF_FILE = sys.argv[1]
    print(CONF_FILE)
    pv_dict = read_conf.readPVDict(CONF_FILE)
    afg = rsAfg(pv_dict)
    return afg

if __name__ == '__main__':
    main()
